Multiversion read-commit order concurrency control

ABSTRACT

A system and method for concurrency control in high performance database systems. Generally includes receiving a database access request message from a transaction. Then, generating an element that corresponds to the access request message. The element type is that of a read element, commit element, validated element, or restart element. The element is then posted to a read-commit (RC) queue. If the element is a commit element, an intervening validation of the transaction is performed. Upon the transaction passing validation the requested database access is performed.

CLAIM TO PRIORITY

The present application is a continuation-in-part of U.S. patent application Ser. No. 10/001,193, filed Nov. 15, 2001, now U.S. Pat. No. 7,051,028, and entitled “Concurrency Control in High Performance Database Systems,” which claims priority to U.S. Provisional Patent Application No. 60/249,084, filed Nov. 15, 2000, and entitled “Read-Commit Concurrency Control System and Method.” The present application also claims priority to U.S. Provisional Patent Application No. 60/380,884, filed May 16, 2002, and entitled “Multiversion ROCC for Concurrency Control.” The identified utility and provisional patent applications are hereby incorporated by reference in their entirety.

FIELD OF THE INVENTION

The present invention relates to concurrency control in computerized database systems and, more particularly, to a read-commit order concurrency method, based on optimistic mechanisms, that is deadlock free.

BACKGROUND OF THE INVENTION

In recent years the Internet has grown so fast that E-businesses are becoming highly profitable. Internet database systems provide business information from which an unprecedented number of customers may access. With the drastic growth of Internet users, the demand for higher system throughput becomes urgent. Replicated database systems have attracted considerable attention due to their apparent advantages of improved data availability and system scalability. In a replicated database system, identical copies of data objects are kept in multiple geographically distributed sites to provide nearby customers with fast and easy accesses. The multiple copies of data objects also provide a much more reliable information service against system outages, which might otherwise cause severe losses in E-businesses, such as online stock trading systems. However, while the replication paradigm brings the benefit of quick response to read-only operations, it does cause new problems—the workload of updates in each site increases proportionally to the number of replicas of data objects. It has been discussed that the deadlock rate has a cubic growth versus the number of replicas. This implicates that two-phase locking, the most commonly used locking-based concurrency control method, cannot meet the increasing needs of high performance in today's Internet database systems such as online shopping systems, stock trading systems, etc.

The relative performance of three different approaches for concurrency control, i.e., blocking-based, immediate-restart, and optimistic, under a variety of modeling assumptions have been studied. In the blocking-based approach, transactions set read locks on objects that they read, then upgrade the read locks to write locks for the objects that they also write. When a lock request is denied, the requesting transaction is blocked. Wait-for-graph is used for deadlock detection. In the immediate-restart approach, transactions lock the objects in the same way as in the blocking-based approach, but they are aborted immediately when a lock request is denied. In the optimistic approach, transactions are allowed to be executed unhindered and are validated only after they have reached their commit points, but they are restarted if any object they read has been written by other committed transactions. The conclusion is that a concurrency control method that tends to conserve physical resources by blocking transactions, such as S2PL, out performs immediate-restart and optimistic methods for medium to high levels of resource utilization. In an environment of sufficient resources of CPUs and disks, an optimistic method is a better choice in terms both system throughput and transaction response time.

With the fast progress of technologies, the available resources may no longer be a bottleneck, e.g., CPU speed increases drastically and the costs of disks and CPUs are dropping quickly. Thus, optimistic approaches seem more promising than ever. It has been proposed that a hybrid two-phase concurrency control method be used wherein, in the first execution phase an optimistic concurrency control method is used, and in the restart phase a conservative 2PL is used. With such a method it was found that, statistically, transactions intend to access the same dataset as before, if they are restarted due to access conflicts. With the access invariance property, this method ensures, at most, one transaction re-execution. This eliminates the repeated restart problems in optimistic concurrency control methods and makes transaction response time more predictable.

SUMMARY OF THE INVENTION

The disadvantages and limitations of the prior art are, at least in part, overcome by the concurrency control system and method of the present invention.

The present invention provides a method for concurrency control in high performance database systems. The method generally includes receiving a database access request message from a transaction. Then, generating an element that corresponds to the access request message. The element type is that of a read element, commit element, validated element, or restart element. The element is then posted to a read-commit (RC) queue. If the element is a commit element, an intervening validation of the transaction is performed. Upon the transaction passing validation the requested database access is performed.

The system of the present invention provides for a client-server environment wherein the client produces a transaction that incorporates the database access request message. The server includes a scheduler and a data manager. The scheduler operates to generate an element corresponding to the database access request message, post it to the RC-queue, and perform an intervening validation of the transaction upon the posting of a commit element. The data manager performs the requested database access upon the transaction passing intervening validation.

Within the system and method of the present invention, the generated element is always posted to the bottom of the RC-queue. Further, the intervening validation generally comprises failing the validation of a transaction when the transaction has at least two elements that are in conflict with intervening elements of another transaction and passing the validation of a transaction when the transaction has only one element that conflicts with intervening elements of another transaction. The intervening validation ensures that a validated transaction is represented by only one element in the RC-queue. The requested database access performed by the system and method is performed in the same order as the postings to the RC-queue.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram of a centralized database system incorporating the present invention.

FIG. 2 is an example of a centralized data structure, i.e., an RC-queue, used by the concurrency control system and method of the present invention.

FIG. 3 is a pseudo-code listing of the intervening validation technique that is used by the concurrency control system and method of the present invention.

FIG. 4 is a pseudo-code listing of the client-side procedure of the concurrency control system and method of the present invention.

FIG. 5 is a pseudo-code listing of the server-side scheduler procedure of the concurrency control system and method of the present invention.

FIG. 6 is a pseudo-code listing of the server-side data manager procedure of the concurrency control system and method of the present invention.

FIG. 7 is an example of the execution flow of the concurrency control system and method of the present invention.

FIG. 8 depicts the RC-queue from FIG. 7 after transaction T1 has been validated.

FIGS. 9A–9D are comparison graphs of throughput and restarts for the concurrency control system and method of the present invention against the prior art methods of 2PL, OCC and WDL in a client-server environment.

FIG. 10 diagrams a test scheme for illustrating the “write skew” in the Snapshot method of concurrency control.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

The present invention comprises a system and method for concurrency control in centralized high performance database systems. The concurrency control system 10 and method of the present invention uses several techniques to reduce restarts and improve performance in terms of system throughput and transaction response time. Specifically, a centralized data structure, i.e., a Read-commit queue (RC-queue), is used to record the execution order of transactions. Four types of elements are defined in the RC-queue for the convenience of transaction validation and include: 1. Read element; 2. Commit element; 3. Restart element; and 4. Validated element. New elements are en-queued to the rear of the RC-queue and validated elements are removed from the front of the RC-queue. An intervening validation technique used by the concurrency control system of the present invention utilizes element conflict instead of operation conflict to reduce validation failures. In contrast to traditional order, concurrency control schemes, which abort transactions when conflicts occur, the concurrency control scheme of the present invention only aborts transactions when two or more intervening conflicts occur. This scheme significantly reduces restarts to virtually the same level as 2PL (two phase locking) systems. Transactions can be controlled to complete successfully at any execution phase by using an over-declaration technique or an access invariance property.

The concurrency control system 10 and method of the present invention is described with reference to a client-server database system, a block diagram of which is provided in FIG. 1. In this system, clients 12 may access the database 14 of a server 16 locally or through the Internet. The server 16 additionally includes a database scheduler 17 and a database data manager 18. In particular, the present invention is described in reference to a centralized single site system, however, it should be noted that the present invention may be easily extended to a replicated database system over a wide area network without departing from the spirit or scope of the invention.

In the centralized single site system, a high throughput and low response time are desired, and locking-based concurrency control methods such as 2PL no longer fit the definition due to the enormous number of users and uncertain network delay, which increases the “intratransaction think time.” It is assumed that a transaction may send multiple data access requests to the system, each of which contains one or more access operations. When the system 10 receives a request message from a client 12, it generates a corresponding element 19 and posts it to an RC-queue 20 (see FIG. 2), which is used to validate transactions when they enter the commit phase. An element 19 in the RC-queue 20 contains the identifiers of the transaction, the data items to be accessed, and other information.

An example of an RC-queue 20 is shown in FIG. 2. As indicated above, the elements 19 in the queue 20 are divided into four types: a read element, a commit element, a validated element, and a restart element. A read element represents the read/write request message a transaction submits. A commit element represents a commit request message. A transaction may own multiple read elements in the RC-queue since it may submit multiple requests. Note that a read element only contains the identifiers of data items requested to read. All the data items that the transaction requests to write are contained in the commit element because a deferred write technique is used to avoid cascading abort. The data manager 18 performs data accesses in the same order as they appear in the RC-queue 20. In this way, the element 19 order in the RC-queue 20 represents the real execution order of data accesses that the system 10 performs, and can be used for transaction validation. When the validation of a transaction execution fails, and the client 12 intends to access the same data set (e.g., access invariance property), then the system 10 generates a restart element.

The restart element contains all the identifiers of data items and the operations that the failed transaction intended to perform. If the client 12 intends to access a completely new data set after a validation failure, then the system 10 preferably aborts the failed transaction and treats an access request from the client 12 as if they were from a newly arrived transaction. Validated elements correspond to transactions that have been validated, or transactions that do not need validation. When a validated element represents a transaction that does not need validation, it contains all the access requests of that transaction.

FIG. 2 also shows the format of elements 19 in the RC-queue 20. An element 19 comprises four fields: Tid field 22, element type field 24, access field 26, and next pointer field 28. The Tid field 22 provides the identifier of the transaction. The access field 26 holds the read/write set that the message requests to read/write. The element type field 24 comprises three (3) bits: V 30, C 32, and R 34. The V bit 30 is set to one (1) when the element 19 is a validated element corresponding to a transaction that does not need validation, or when the transaction has passed validation. The C bit 32 is set to one (1) if the element 19 is a Commit element, indicating the corresponding request message is a commit request message. The R bit 34 is set to one (1) if the element 19 is a restart element, indicating the transaction is a restart transaction and has the access invariance property. The access invariance property indicating that the transaction will access the same data items as it did in the first execution. The next pointer field 28 includes a pointer that is set to point to the next element 19 in the queue 20. The pointer of the last arrived element 19 is set to null 36, as shown, because no transaction arrives after it. In this instance, a linked list is used to represent the RC-queue 20 for simplicity. The front element 19 is removed from the queue 20 if it is a validated element. New elements 19 enter the queue 20 as the rearmost element 19 in the queue 20. Alternatively, doubly linked lists may be used to speed up the validation process. In the example of FIG. 2, transactions T0 and T3 each own one read element, T1 owns one read element and one commit element, and T2 owns one restart element. In the restart element of T2, the validated bit 30 is set to one (1), indicating that T2 needs no further validation.

Intervening Validation Technique

To employ the RC-queue 20, the concurrency control system and method of the present invention utilizes an intervening validation technique. It is has been named “intervening” because the validation only checks the elements 19 of the transaction to be validated and the intervening element from other transactions in the RC-queue 20 for validation. In this technique the concept of element conflict is used to determine whether or not a transaction can be validated. For purposes of the present invention, an element 19 is deemed to conflict with another element 19 if any of the operations they contain are in conflict. Pseudo-code detailing the operation of the intervening validation technique is provided in FIG. 3.

A validation technique is critical to an optimistic concurrency control method. The intervening validation technique of the present invention uses the RC (read-commit) structure to achieve desired properties such as low restart rates, high system throughput, short and predictable transaction response time, etc. With the concurrency control system and method of the present invention, the system scheduler 17 maintains the RC structure. When a commit request message arrives, the scheduler 17 generates a commit element, i.e., an element with C bit 32=1, and posts it to the RC-queue 20, then the validation process starts.

Per the pseudo-code of FIG. 3, the process traverses the queue 20 from the commit element upward until it reaches the first read element of the same transaction. To further understand, let “first” be the first element encountered. The intervening validation technique checks if “first” conflicts with the intervening elements. The “first” element's intervening elements are the elements of other transactions between the “first” element and the element of the same transaction after it. If “first” does not conflict with the intervening elements, then the first read element and the element of the same transaction right after it are combined. The combined element is then deemed to be “first.” The intervening validation process continues to check if the new “first” conflicts with its intervening elements. This search and check process proceeds until the “first” conflicts with its intervening elements, or until the commit element of the same transaction is reached finding no conflicts. If no conflicts are found between the “first” and its intervening elements, then the validation passes. The scheduler 17 sends a commit request message to an execution queue for the data manager 18 to perform write operations upon the validated transaction, otherwise the scheduler 17 sends out a restart request message.

If a conflict is found, per the pseudo-code of FIG. 3, let “second” be the commit element. The validation process then checks if “second” conflicts with its intervening elements in the same manner described above. The “second” element's intervening elements are the elements of other transactions between the “second” and the element of the same transaction before it. If both “first” and “second” conflict with their intervening elements, then validation fails. Otherwise, validation passes.

The intervening validation technique operates to swap adjacent elements if there is no conflict between them, since the resulting order is equivalent to the original order in terms of a serialization graph. A transaction validated by the intervening validation technique is eventually represented by only one equivalent element 19 in the RC-queue 20. By use of the intervening validation technique, a “read-commit” order concurrency control system and method of the present invention can be produced. The correctness of this method can be proven as follows:

-   -   Theorem: The read-commit concurrency control system and method         produces serializable execution of transactions.     -   Proof: With the read-commit concurrency control system and         method, the data manager 18 ensures that the disk access         execution order is the same as RC order. The intervening         validation technique guarantees that all validated transactions         are represented by only one element 19 in the RC-queue 20. Thus,         the element order in the RC-queue 20 is the equivalent serial         transaction execution order.

With the intervening validation technique and the theorem of its correctness, three corollaries can be developed:

-   -   Corollary 1: A transaction does not need validation if it has         only one element 19 in the RC-queue 20.     -   Corollary 2: A restart transaction does not need validation if         it holds access invariance property.     -   Corollary 3: A transaction always passes validation if all of         its intervening elements are read elements.

Corollary 1 is obvious, since there are no intervening elements if a transaction has only one element in the RC-queue, in which case validation is unnecessary. Corollary 2 is correct because data access requests can always be placed into one element for a restart transaction, if it holds access invariance property. With respect to corollary 3, the intervening elements only conflict with the commit element (deferred writes), thus, validation always passes (a validation failure needs the intervening elements conflicting with both the commit element and any read element of the transaction).

Read-Commit Order Concurrency Control—Centralized Database System

As stated earlier, within a centralized database system 10 it is presumed that clients 12 may access the database 14 locally or through the Internet. A transaction may send multiple data access request messages, each time containing one or more access operations. When a new request message arrives, a corresponding element 19 is generated. The element 19 is then posed to an RC-queue 20 maintained in the system 10. The data manager 18 executes operations from different transactions based on FCFS (first come first served) discipline, if they conflict with each other. Elements 19 in the RC-queue 20 are divided into the four previously-described types: read element, commit element, restart element, and validated element. When a commit message comes, a commit element is generated and the intervening validation process is invoked. If validation passes, the data manager 18 performs write operations for the validated transaction. Otherwise, the transaction is aborted or restarted.

The various procedures required to actually achieve the read-commit order concurrency control of the present invention can be split into three categories: 1. Client-side procedure; 2. Server-side scheduler procedure; and 3. Server-side data manager procedure. Each of the procedures is described below with reference to the pseudo-code listings of FIGS. 4, 5, and 6, respectively.

Client-Side Procedure

The client-side procedure, see FIG. 4, is initiated with a transaction that sends a message containing the read/write request from the client 12 to the database site, e.g., server 16. The client 12 waits for the values of the requested data items to be returned from the database site. If all requested data has been received and there are no further read/write operations to request, the client side procedure determines if the client 12 wants to abort or commit. If the client 12 wants to abort, an abort message is sent to the database site, the transaction ends, and all resources used by the transaction are released. If the client 12 wants to commit, it sends a commit request message to the database site. Once a commit request message has been sent, the client 12 waits for an acknowledgement message from the database site. If a success message is received from the database site, the transaction has committed and all the resources used by the transaction can be released. If no success message is received, i.e., the transaction has not committed, then it is presumed that values of reads received from the database site are from a restart message and, as such, the values for writes based on the newly received values are recalculated. The client 12 then determines whether to restart the transaction or abort. If restarting the transaction, the client 12 sends a restart message with the new writes to the database site. If not restarting, the client 12 sends an abort message to the database site.

Server-Side Scheduler Procedure

In the server-side scheduler procedure, see FIG. 5, the scheduler 17 awaits messages from the client 12. If a database access request message arrives, the server-side scheduler 17 generates a read element, fills in the read element's fields with the information in the message, posts the read element to the RC-queue 20, and delivers the access request message to an execution queue. Note that the delivery order of the request messages must be the in same order as their corresponding read elements in the RC-queue.

If a commit request message arrives, the server-side scheduler 17 generates a commit element, posts it to the RC-queue 20, and invokes the intervening validation technique (described above). If the validation passes, the server-side scheduler 17 delivers the commit request message to the execution queue. If the validation does not pass, the server-side scheduler 17 removes all of the elements 19 of the transaction from the RC-queue 20 and assesses whether the transaction has the access invariance property. If the transaction does indeed have the access invariance property, the server-side scheduler 17 generates a restart element, posts the restart element to the RC-queue 20, delivers a restart request message to the server-side data manager 18, and sends a restart message with the new values of reads to the client 12 and awaits its answer. Note that the restart element contains the sets of all operations that the transaction requests, assuming the transaction access invariance property holds.

If a restart message with updates is received from the client 12, the server-side scheduler 17 operates to send the updates to the server-side data manager 18.

If a commit success message is received from the client 12, the server-side scheduler 17 transfers the success message to the client 12, marks the element 19 of the validated transaction in the RC-queue 20 as validated (i.e., set the validated V bit 30 to 1 [one]) if there is one or more uncommitted transactions before it in the RC-queue 20 or removes all elements 19 of committed transactions from the RC-queue 20 if there is no uncommitted transactions before it, and releases other resources used by the committed transaction.

If an abort message is received from the client 12, the server-side scheduler 17 removes all elements 19 of the transaction from the RC-queue 20 and releases all the resources used by the transaction.

Server-Side Data Manager Procedure

While there are operations to be performed, the server-side data manager 18 operates to retrieve messages from the execution queue, per the pseudo-code of FIG. 6. If the retrieved message is an access message, the server-side data manager 18 operates to set the read locks to the data items to read, performs the read operations, releases the read locks, and holds the write operations. If the access message requests data items that are write-locked, the server-side data manager 18 waits until the write-locks are released before setting the read locks.

If the retrieved message is a validation success message, the server-side data manager 18 operates to set the write locks on the data items to write, perform the write operations, release the write locks, send a commit success message to the server-side scheduler 17 after completing execution of each transaction and, finally, release all resources used by the committed transaction. If the data items are already locked, then the server-side data manager 18 waits for those locks to be released before locking them again for the present write operation.

The server-side data manager sets read-locks and write-locks before it performs operations to guarantee the execution order of conflicting operations from different transactions. A deadlock will not occur even though the data manager 18 uses locks. This is because all writes involved in a cycle will be invalidated, and the transaction will be aborted or restarted before the write operations intend to acquire a write-lock and execute. Moreover, unlike S2PL which releases locks only after the transaction commits, the read order concurrency control system and method of the present invention releases each read lock once the read operation completes. The blocking time caused by write-locks are negligible as well because the write-locks are acquired only after the transaction passes validation and are released immediately after the writes complete.

Operation of Read Order Concurrency Control

With reference to FIG. 7, an example of how the read-commit order concurrency control system and method of the present invention functions is now described. As demonstrated in FIG. 7, suppose that there is a receive queue 40 that contains all of the request messages from clients 12. The first is an access request message 44 for transaction T0, which asks for read access of data items x1 and x3. Correspondingly, a read element is posed to the RC-queue 20 with Tid=0, V=0, C=0, R=0 and Readset={1,3}. Then the message is delivered to an execution queue 42 for the data manager 18 to perform operations. The second message 46 in the receive queue 40 is T1 asking for read access of data items x1, x2 and x3. A corresponding read element is posed to the RC-queue 20 with Tid=1, V=0, C=0, R=0 and Readset={1,2,3}. The third message 48 is for T2 to read data items x1 and x3, and then write data item x3. The fifth message 52 is a commit request message from T2. Note that no writeset is placed in the read element (the third element). Instead, the writes of x3 are placed in the commit element (the fifth element) though the writes are still sent to the database sites for data log. This is because the data manager 18 delays the write operations to avoid cascading abort. The request message is then put to the execution queue 42 for execution. The data manager 18 executes the operations orderly based on the execution queue 42 if conflicts occur (this is enforced by the data manager 18).

The fourth message 50 is an access request message with a validated mark, which requests reads of data items x1, x2, and writes of x3. This means the client 12 is sure that the transaction only needs one request message. Correspondingly, the element representing T3 is marked as validated (V=1), since no validation is needed if the transaction has only one element in the RC-queue 20 (see Corollary 1, described above). When T2's commit request message comes after T3, its validation fails because it has two elements conflicting with an intervening element of the RC-queue 20—the element corresponding to T3. Thus, the elements (depicted as dashed elements on FIG. 7) are removed from the RC-queue 20 and a restart element is posed to the RC-queue 20. A corresponding restart request message is then put to the execution queue 42 to re-access the data items it requested before. Since the commit request message of T1 arrives during the validation of T2, and its commit element is posed before T2's restart element, the read-commit order concurrency control system and method of the present invention delivers T1's commit request message before T2's restart request message to the database sites, as can be seen in the execution queue 42. Note that even though transaction T3 committed, its element in the RC-queue 20 cannot be removed until it becomes the front of the queue, or all elements before it are marked as validated. This is because it may be involved in a cycle. As in the example, T2 and T3 forms a cycle of T2->T3->T2. If T3's validated element were removed from RC-queue 20 before T2's validation, the cycle would not be detected by T2's validation.

After T2 fails in validation, T1's commit message activates the intervening validation process for T1. T1's “first” element 19 in the RC-queue 20 indicates that it reads x1, x2, and x3. Its intervening element is T3. “First” conflicts with its intervening element, since T3 writes x3 while T1 read x3 (a read-write conflict). The intervening validation process then checks if the “second,” which in this instance is the commit element, conflicts with its intervening element. T3 is also the “second” element's intervening element in this example. The intervening validation process finds that no conflict exists between the “second” element and its intervening element T3. Thus, T1 passes validation. Note that if traditional optimistic concurrency control were used, it would fail T1 because of the read-write conflict on x3. The intervening validation technique of the read-commit order concurrency control system and method of the present invention merges the “second” with the “first” and marks it as validated. The resulting RC-queue 20 after the T1's validation is shown in FIG. 8, in which T1 is marked as validated (V=1), and T2 is marked as restarted and of access invariance property (R=1 and V=1).

The read-commit order concurrency control system and method of the present invention, and the intervening validation technique that it employs, provides various advantages to its users. The first of many is the RC-queue 20, a simplified version of the stored serialization graph (SSG), for transaction validation. The transaction validation of the read-commit order concurrency control only needs to check intervening conflicts when a commit request arrives. This feature helps to significantly reduce validation complexity and validation failures. Specifically, unlike the SSG method, the cycle search is very simple. The read-commit order concurrency control only needs to do intervening conflict checks during validation. The RC-queue 20 is easy to maintain, since only two pointer copy operations are needed when a new request message arrives. Further, unlike other optimistic concurrency control methods that restart transactions that conflict with committed transactions, the intervening validation technique only fails those transactions that have at least two elements conflicting with intervening elements of other transactions. The validations of those transactions that have only one element conflicting with other transactions always succeed. This helps to significantly reduce transaction restarts.

A static transaction may predeclare all of its data access operations in a single message. For such transactions that only submit one access request message, no validation is needed with the read-commit order concurrency control system and method of the present invention. The corresponding element of such a transaction in the RC-queue is always marked as validated. The example transaction is T3 described above. The “single message transaction that doesn't need validation” property of the read-commit order concurrency control system and method is also used for restarted transactions. Like static transactions, a restarted transaction does not need validation since it has only one element 19 in the RC-queue 20. The database system 10 will read the data items that the restart message requests, send back the values of reads and then wait for the values of writes. In this way, the system 10 guarantees the execution values of reads and then waits for the values of writes. In this way, the system guarantees that the execution of restarts succeeds. The feature is very attractive in real time systems—the guaranteed success of transaction re-execution makes the transaction response time more predictable, and, by making a transaction in urgent need of a successful execution as a fake restart transaction (overdeclare the data items it intends to access), it will succeed in its first execution without validation. A dynamic transaction can be converted to a static transaction via an over-declaring technique, described in “Request Order Linked List (ROLL): A Concurrency Control Object,” The Proceedings of the IEEE International Conference of Data Engineering (Perrizo 1991) which is hereby incorporated by reference, and succeeds in its first execution phase. Thus, the read-commit order concurrency control system and method of the present invention provides a concurrency control method that makes transaction response time predictable and controllable, a desired feature in real time systems.

An interesting benefit provided by the intervening validation technique is that the deferred write technique introduces less probability of validation failures than with other optimistic concurrency control methods. By combining all writes of a transaction into one element, and using the element conflict concept in the intervening validation method, the chance of aborts due to conflicts with other transactions is significantly reduced.

Comparison with Existing Schemes

The present invention's read-commit order concurrency control was compared with 2PL, OCC and WDL (wait depth limit) in a client-server environment. The simulation results are provided in FIGS. 9A–9D. The parameter settings are as follows: 1. A client is assumed to send multiple access requests to the data server; 2. The average intratransaction think time is two seconds when considering the network delay and the interaction required between the client and the server; 3. The average inter-transaction time is zero, to form a closed system; 4. The database size is 1000 pages; 5. Transaction size varies from 4 through 6 pages for low data contention environments, see FIGS. 9C and 9D, and 10 through 16 pages for high data contention environments, see FIGS. 9A and 9B; 6. Disk I/O is 35 ms; 7. CPU processing time per page is 10 ms; and 8. The system has 10 CPUs and 20 disks in total.

The transaction throughput shown in FIGS. 9A and 9C is defined as the number of transactions completed per second. The restart number shown in FIGS. 9B and 9D is defined as the number of restarted transactions per thousand committed transactions. From the four figures, it can be seen that the read-commit order concurrency control system and method of the present invention has an advantage over 2PL, OCC, and WDL in terms of throughput and restarts.

It should be noted that, for the simplicity of discussion, the present invention was described above with the assumptions of transaction access invariance to guarantee the success of transaction re-execution. It can be removed easily by simply sending abort messages after validation failure, and treat a restarted transaction as if it were a newly arrived transaction. It is assumed that the new values of writes have to be calculated by the client when transaction validation fails, and thus, new values of reads have to be transferred to the client. This is a strict assumption. In many application cases, the new writes can be decided locally based on the new values of read, thus, transaction response is reduced further.

The present invention's read-commit order concurrency control was also compared with the Snapshot method of multiversion concurrency control. The Snapshot method was invented in 1995 and adopted by Oracle and PostgreSQL as a method for “serializable” isolation level transactions. However, as pointed out in “A critique of ANSI SQL isolation levels,” ACM SIGMOD, 1995, pp. 1–10H, the Snapshot method suffers a “write skew” problem and, thus, is not serializable nor does it have a correctness guarantee. The present invention provides for better performance than the Snapshot method while at the same time maintaining the correctness.

The Snapshot method utilizes a first-committer-wins scheme to avoid a lost updates problem. In other words, a transaction always reads data from a snapshot of the (committed) data as of the time the transaction started, called its Start-Timestamp. Reads from a transaction are never blocked as long as the snapshot data can be maintained. The write of the transaction (e.g., updates, inserts, and deletes) are also in this snapshot so that they can be read again if the transaction accesses the data a second time. Updates of other transactions beginning after the transaction Start-Timestamp are invisible to the transaction.

Suppose there is a transaction T1. When T1 is ready to commit, it gets a Commit-Timestamp, which is larger than any existing Start-Timestamp or Commit-Timestamp. The transaction commits only if no other transaction T2 with a Commit-Timestamp in the time interval of T1 (Start-Timestamp to Commit-Timestamp) wrote data that T1 also wrote. Otherwise, T1 will abort. The result is the so-called first-committer-wins policy. The Snapshot method allows the following history: r1[x=50]r1[y=50]r2[x=50]r2[y=50]w1[y=−40]w2[x=−40 ]c1c2 Clearly the above history is not serializable and a system that allows the above history has a write skew problem.

The Oracle 9 iis one of the latest versions of an Oracle database product. It is an object-oriented relational database management system. The access unit is a record (row) instead of a field. Yet, it is still possible to detect a write skew problem in the Oracle 9 i using the testing scheme shown in FIG. 10, even though the transaction isolation level is set as serializable.

Now, knowing that the multiversion read-commit order concurrency control operates as follows:

A. Read committed (the latest committed version) to avoid cascading abort;

B. Set timestamp for each element read and each element write;

C. When the transaction commits, check if there are two intervening element conflicts based on the read/write timestamps, if so, the transaction commits. Otherwise the transaction aborts; and

D. Unlike read-commit order concurrency control, there is not deferred write. This is because the multiversion read-commit order concurrency control of the present invention allows an immediate write without causing a cascading abort problem.

One can determine what the timestamps are for read and write operations as well as what committed data version should be read when a read request arrives.

These determinations can be made by following the idea of the Snapshot method, i.e., all reads should be read the latest data version committed before the Start-timestamp. This Start-timestamp may be any time before the first read of the transaction. Thus, the read timestamp is the Start-timestamp. All the timestamps for writes can be set to be the Commit-timestamp. Then, the intervening method can be used to check if there are two intervening conflicts. The transaction has to abort if there are two intervening conflicts. Unlike the Snapshot method, however, the present invention has to maintain an RC-queue. The maintenance of the RC-queue is the same as in the read-commit order concurrency control method. All committed transactions have a single timestamp. The single timestamp could be either its Start-timestamp or its Commit-timestamp, depending on their conflict history.

Because of the change introduced in the multiversion read-commit order concurrency control method of the present invention, the “write skew” problem in the Snapshot method can be prevented. That is, the following history is not allowed in the method of the present invention: r1[x=50]r1[y=50]r2[x=50]r2[y=50]w1[y=−40]w2[x=−40]c1c2 where:

r1[x=50]r1[y=50] is in the Start-timestamp of T1;

r2[x=50]r2[y=50] is in the Start-timestamp of T2; and

c1 in is the Commit-timestamp of T2.

This history is not allowed because at the time T1 commits, the timestamp is set to its Commit-timestamp (not its Start-timestamp) because it found a conflict r2[y=50]w1[y=−40]. Thus, at the time when T2 decides to commit, the history recorded in the RC-queue will be: r2[x=50]r2[y=50]r1[x=50]r1[y=50]w1[y=−40]c1 w2[x=−40]c2 where:

r2[x=50]r2[y=50] is in the Start-timestamp of T2;

r1[x=50]r1[y=50]w1[y=−40]c1 is in the Commit-timestamp of T1; and

w2[x=−40] c2 is in the Commit-timestamp of T2,

and the intervening element conflict check will find two intervening conflicts: r2[y=50]w1[y=−40] and r1[x=50]w2[x=−40]. Thus, T2 will abort.

The multiversion read-commit order concurrency control method of the present invention has a better performance than the Snapshot method since it has less restarts. The Snapshot method uses the first-committer-wins policy. Thus, whenever there is a write in an interval of a transaction (Start-timestamp, Commit-timestamp), the transaction has to abort. An example history is r2[x=50]r2[y=50]r1[x=50]r1[y=50]w1[x=−40]c2. It is equivalent to T1→T2, thus serializable. The Snapshot method will abort transaction T2 but the present invention will not.

The present invention may be embodied in other specific forms without departing from the spirit of the essential attributes thereof; therefore, the illustrated embodiments should be considered in all respects as illustrative and not restrictive, reference being made to the appended claims rather than to the foregoing description to indicate the scope of the invention. 

What is claimed:
 1. A method for concurrency control in a computerized database system, said method comprising: receiving a database access request message from a transaction; generating an element to correspond to the access request message; posting said element to a read-commit (RC) queue; invoking an intervening validation of said transaction upon the posting of a commit element to said RC-queue, wherein said intervening validation determines a conflict based upon a read/write timestamp, wherein all committed transactions have a single timestamp and wherein said intervening validation comprises: failing validation of said transaction upon said transaction having at least two elements that conflict with intervening elements of another transaction; and passing validation of said transaction upon having at most one element that conflicts with intervening elements of another transaction; and performing the requested database access upon said transaction passing said intervening validation.
 2. The method of claim 1, wherein said element is always posted to a bottom of said RC-queue.
 3. The method of claim 1, wherein a write database access request message from said transaction is contained within said commit element.
 4. The method of claim 1, wherein the requested database access is performed in the same order as the postings to said RC-queue.
 5. The method of claim 1, wherein said intervening validation process ensures that a validated transaction is represented by only one element in said RC-queue.
 6. A concurrency control system, comprising: a client, wherein said client produces a transaction having a database access request message; a server in communication with said client, said server having a scheduler and a data manager, wherein said scheduler: generates an element corresponding to said database access request message; posts said element to a read-commit (RC) queue; and performs an intervening validation of said transaction when said element comprises said commit element, wherein said intervening validation determines a conflict based upon a read/write timestamp and wherein all committed transactions have a single timestamp, and wherein said intervening validation fails upon said transaction having at least two elements that conflict with intervening elements of another transaction and wherein said intervening validation passes upon said transaction having at most one element that conflicts with intervening elements of another transaction; and wherein said data manager performs the requested database access upon said transaction passing said intervening validation.
 7. The system of claim 6, wherein the generated element is always posted to the bottom of said RC-queue.
 8. The system of claim 6, wherein a write database access request message corresponds to a commit element.
 9. The system of claim 6, wherein the requested database access is performed in the same order as the postings to said RC-queue.
 10. The system of claim 6, wherein the performance of said intervening validation ensures that a validated transaction is represented by only one element in said RC-queue.
 11. A method for concurrency control in a computerized database system, comprising the steps of: receiving a database access request message from a transaction; generating an element to correspond to the access request message; posting said element to a read-commit (RC) queue; performing an intervening validation of said transaction when said element comprises a commit element, wherein all committed transactions have a single timestamp and wherein said intervening validation determines a conflict based upon a read/write timestamp, and wherein that single timestamp is selected only from a start-timestamp or a commit-timestamp; and performing the requested database access upon said transaction passing said intervening validation or denying the requested database access upon said transaction failing said intervening validation, wherein said intervening validation fails upon said transaction having at least two elements that conflict with intervening elements of another transaction and wherein said intervening validation passes upon having only one element that conflicts with intervening elements of another transaction.
 12. The method of claim 11, wherein said element is always posted to a bottom of said RC-queue.
 13. The method of claim 11, wherein a write database access request message from said transaction is contained within said commit element.
 14. The method of claim 11, wherein the requested database access is performed in the same order as the postings to said RC-queue.
 15. The method of claim 11, wherein said intervening validation process ensures that a validated transaction is represented by only one element in said RC-queue. 